  
const movePostElements = (array, startIndex, len, deleteCount, addElements) => {
    if (deleteCount === addElements.length) return;
    // 如果添加的元素和删除的元素个数不相等，则移动后面的元素
    if(deleteCount > addElements.length) {
        // 删除的元素比新增的元素多，那么后面的元素整体向前挪动
        // 一共需要挪动 len - startIndex - deleteCount 个元素
        for (let i = startIndex + deleteCount; i < len; i++) {
            let fromIndex = i;
            // 将要挪动到的目标位置
            let toIndex = i - (deleteCount - addElements.length);
            if (fromIndex in array) {
            array[toIndex] = array[fromIndex];
            } else {
            delete array[toIndex];
            }
        }

        // 注意注意！这里我们把后面的元素向前挪，相当于数组长度减小了，需要删除冗余元素
        // 目前长度为 len + addElements - deleteCount
        for (let i = len - 1; i >= len + addElements.length - deleteCount; i --) {
            delete array[i];
        }
    }
    
    if(deleteCount < addElements.length) {
        // 删除的元素比新增的元素少，那么后面的元素整体向后挪动
        // 思考一下: 这里为什么要从后往前遍历？从前往后会产生什么问题？
        for (let i = len - 1; i >= startIndex + deleteCount; i--) {
            let fromIndex = i;
            // 将要挪动到的目标位置
            let toIndex = i + (addElements.length - deleteCount);
            if (fromIndex in array) {
            array[toIndex] = array[fromIndex];
            } else {
            delete array[toIndex];
            }
        }
    }
}
const sliceDeleteElements = (array, startIndex, deleteCount, deleteArr) => {
    console.log(Object.prototype.toString.call(array));
    for (let i = 0; i < deleteCount; i++) {
      let index = startIndex + i;
      // 越界
      if (index in array) {
        let current = array[index];
        deleteArr[i] = current;
      }
    }
  };

// splice 用于数组切割或在切割位置新增元素，返回值是切割的数组
Array.prototype.splice = function(startIndex, deleteCount, ...addElements)  {
    let argumentsLen = arguments.length;
    // 得到原数组
    // 为什么不直接使用原数组 
    // 让O成为回调函数的对象传递（强制转换对象） 严谨
    let array = Object(this);
    let len = array.length;
    let deleteArr = new Array(deleteCount);
     
    // 如果函数超过10行 可以分成子涵数写
    // 拷贝删除的元素
    sliceDeleteElements(array, startIndex, deleteCount, deleteArr);
    // 移动删除元素后面的元素
    movePostElements(array, startIndex, len, deleteCount, addElements);
    // 插入新元素
    for (let i = 0; i < addElements.length; i++) {
      array[startIndex + i] = addElements[i];
    }
    // 数据严谨 长度对标 维护数据正确性
    array.length = len - deleteCount + addElements.length;
    return deleteArr;
}


  
const arr = [1,2,3,4,5,6]

let newarr=arr.splice(3,3)

console.log(newarr,arr)

newarr=arr.splice(1,0,99,89)
console.log(arr)
newarr=arr.splice(1,2,99,89)
console.log(arr)

